home *** CD-ROM | disk | FTP | other *** search
/ Aminet 3 / Aminet 3 - July 1994.iso / Aminet / dev / obero / Interfaces3_4.lha / Interfaces / Layers.mod < prev    next >
Text File  |  1994-03-05  |  7KB  |  132 lines
  1. (*
  2. (*
  3. **  Amiga Oberon Interface Module:
  4. **  $VER: Layers.mod 40.15 (28.12.93) Oberon 3.0
  5. **
  6. **   © 1993 by Fridtjof Siebert
  7. **   updated for V39, V40 by hartmut Goebel
  8. *)
  9. *)
  10.  
  11. MODULE Layers;
  12.  
  13. IMPORT
  14.   e * := Exec,
  15.   g * := Graphics,
  16.   u * := Utility;
  17.  
  18. TYPE
  19.   LONGBOOL * = e.LONGBOOL;
  20.  
  21. CONST
  22.   layersName * = "layers.library";
  23.   LTRUE * = e.LTRUE;
  24.   LFALSE * = e.LFALSE;
  25.  
  26. VAR
  27.   base * : e.LibraryPtr;
  28.  
  29. PROCEDURE InitLayers        *{base,- 30}(li{8}         : g.LayerInfoPtr);
  30. PROCEDURE CreateUpfrontLayer*{base,- 36}(li{8}         : g.LayerInfoPtr;
  31.                                          bm{9}         : g.BitMapPtr;
  32.                                          x0{0}         : LONGINT;
  33.                                          y0{1}         : LONGINT;
  34.                                          x1{2}         : LONGINT;
  35.                                          y1{3}         : LONGINT;
  36.                                          flags{4}      : SET;
  37.                                          bm2{10}       : g.BitMapPtr): g.LayerPtr;
  38. PROCEDURE CreateBehindLayer *{base,- 42}(li{8}         : g.LayerInfoPtr;
  39.                                          bm{9}         : g.BitMapPtr;
  40.                                          x0{0}         : LONGINT;
  41.                                          y0{1}         : LONGINT;
  42.                                          x1{2}         : LONGINT;
  43.                                          y1{3}         : LONGINT;
  44.                                          flags{4}      : SET;
  45.                                          bm2{10}       : g.BitMapPtr): g.LayerPtr;
  46. PROCEDURE UpfrontLayer      *{base,- 48}(layer{9}      : g.LayerPtr): BOOLEAN;
  47. PROCEDURE BehindLayer       *{base,- 54}(layer{9}      : g.LayerPtr): BOOLEAN;
  48. PROCEDURE MoveLayer         *{base,- 60}(layer{9}      : g.LayerPtr;
  49.                                          dx{0}         : LONGINT;
  50.                                          dy{1}         : LONGINT): BOOLEAN;
  51. PROCEDURE SizeLayer         *{base,- 66}(layer{9}      : g.LayerPtr;
  52.                                          dx{0}         : LONGINT;
  53.                                          dy{1}         : LONGINT): BOOLEAN;
  54. PROCEDURE ScrollLayer       *{base,- 72}(layer{9}      : g.LayerPtr;
  55.                                          dx{0}         : LONGINT;
  56.                                          dy{1}         : LONGINT);
  57. PROCEDURE BeginUpdate       *{base,- 78}(l{8}          : g.LayerPtr): BOOLEAN;
  58. PROCEDURE EndUpdate         *{base,- 84}(layer{8}      : g.LayerPtr;
  59.                                          flag{0}       : LONGBOOL);
  60. PROCEDURE DeleteLayer       *{base,- 90}(layer{9}      : g.LayerPtr): BOOLEAN;
  61. PROCEDURE LockLayer         *{base,- 96}(layer{9}      : g.LayerPtr);
  62. PROCEDURE UnlockLayer       *{base,-102}(layer{8}      : g.LayerPtr);
  63. PROCEDURE LockLayers        *{base,-108}(li{8}         : g.LayerInfoPtr);
  64. PROCEDURE UnlockLayers      *{base,-114}(li{8}         : g.LayerInfoPtr);
  65. PROCEDURE LockLayerInfo     *{base,-120}(li{8}         : g.LayerInfoPtr);
  66. PROCEDURE SwapBitsRastPortClipRect*{base,-126}(rp{8}   : g.RastPortPtr;
  67.                                          VAR cr{9}     : g.ClipRect);
  68. PROCEDURE WhichLayer        *{base,-132}(li{8}         : g.LayerInfoPtr;
  69.                                          x{0}          : LONGINT;
  70.                                          y{1}          : LONGINT): g.LayerPtr;
  71. PROCEDURE UnlockLayerInfo   *{base,-138}(VAR li{8}     : g.LayerInfo);
  72. PROCEDURE NewLayerInfo      *{base,-144}(): g.LayerInfoPtr;
  73. PROCEDURE DisposeLayerInfo  *{base,-150}(li{8}         : g.LayerInfoPtr);
  74. PROCEDURE FattenLayerInfo   *{base,-156}(li{8}         : g.LayerInfoPtr);
  75. PROCEDURE ThinLayerInfo     *{base,-162}(li{8}         : g.LayerInfoPtr);
  76. PROCEDURE MoveLayerInFrontOf*{base,-168}(layertomove{8}: g.LayerPtr;
  77.                                          otherlayer{9} : g.LayerPtr): BOOLEAN;
  78. PROCEDURE InstallClipRegion *{base,-174}(layer{8}      : g.LayerPtr;
  79.                                          region{9}     : g.RegionPtr): g.RegionPtr;
  80. (* ---   functions in V36 or higher  (distributed as Release 2.0)   --- *)
  81. (* --- REMEMBER: You are to check the version BEFORE you use this ! --- *)
  82. PROCEDURE MoveSizeLayer     *{base,-180}(layer{8}      : g.LayerPtr;
  83.                                          dx{0}         : LONGINT;
  84.                                          dy{1}         : LONGINT;
  85.                                          dw{2}         : LONGINT;
  86.                                          dh{3}         : LONGINT): BOOLEAN;
  87. PROCEDURE CreateUpfrontHookLayer*{base,-186}(li{8}     : g.LayerInfoPtr;
  88.                                          bm{9}         : g.BitMapPtr;
  89.                                          x0{0}         : LONGINT;
  90.                                          y0{1}         : LONGINT;
  91.                                          x1{2}         : LONGINT;
  92.                                          y1{3}         : LONGINT;
  93.                                          flags{4}      : SET;
  94.                                          hook{11}      : u.HookPtr;
  95.                                          bm2{10}       : g.BitMapPtr): g.LayerPtr;
  96. PROCEDURE CreateBehindHookLayer*{base,-192}(li{8}      : g.LayerInfoPtr;
  97.                                          bm{9}         : g.BitMapPtr;
  98.                                          x0{0}         : LONGINT;
  99.                                          y0{1}         : LONGINT;
  100.                                          x1{2}         : LONGINT;
  101.                                          y1{3}         : LONGINT;
  102.                                          flags{4}      : SET;
  103.                                          hook{11}      : u.HookPtr;
  104.                                          bm2{10}       : g.BitMapPtr): g.LayerPtr;
  105. PROCEDURE InstallLayerHook  *{base,-198}(layer{8}      : g.LayerPtr;
  106.                                          hook{9}       : u.HookPtr): u.HookPtr;
  107.  
  108. (*--- functions in V39 or higher (Release 3) ---*)
  109.  
  110. PROCEDURE InstallLayerInfoHook*{base,-0CCH}(li{8}      : g.LayerInfoPtr;
  111.                                             hook{9}    : u.HookPtr): u.HookPtr;
  112. PROCEDURE SortLayerCR       *{base,-0D2H}(layer{8}     : g.LayerPtr;
  113.                                           dx{0}        : LONGINT;
  114.                                           dy{1}        : LONGINT);
  115. PROCEDURE DoHookClipRects   *{base,-0D8H}(hook{8}      : u.HookPtr;
  116.                                           rport{9}     : g.RastPortPtr;
  117.                                           rect{10}     : g.Rectangle);
  118.  
  119.  
  120. (* $OvflChk- $RangeChk- $StackChk- $NilChk- $ReturnChk- $CaseChk- *)
  121.  
  122. BEGIN
  123.  base := e.OpenLibrary(layersName,33);
  124.  IF base=NIL THEN HALT(20) END;
  125.  
  126. CLOSE
  127.  
  128.  IF base#NIL THEN e.CloseLibrary(base) END;
  129.  
  130. END Layers.
  131.  
  132.